package 基本程序设计;

import java.util.Arrays;

/**
 * Created by   song 醉美柳舞之众星捧月
 * Date & Time  2017/10/8 16:24
 */
public class 不定参选择排序冒泡排序二分查找main传参 {
    public static void main(String[] args) {
        //  从“一维数组......”类传过来的    main 传参,   主函数传参
        for (String arg : args) {
            System.out.println(arg);
        }
    }

    // 不定参数      可变长度参数    (只能三个点)
    public static int max(int... array) {
        int result = 0;
        //  java.utils  工具类    ; 专用于排序：  eg:
        //Arrays.sort(array);
        for (int temp : array) {
            if (temp > result) {
                result = temp;
            }
        }
        return result;
    }


    // 线性查找法    数组的查找
    // 在外面调用这个方法  linearSearch(paramName,9)  ; 查询元素9在数组paramName中是第几号下角标
    public static int linearSearch(int[] param, int key) {
        for (int i = 0; i < param.length; i++) {
            if (key == param[i]) {
                return i;
            }
        }
        return -1;
    }


    //   二分查找  先会把数组排序; 比如从小到大   然后通过找中间元素 比较大小  一次次重复找中间轴  来进行查找
    public static int binanySearch(int[] param, int key) {
        //排序
        selectSort(param);
        // 查找
        int low = 0;
        int high = param.length - 1;
        while (high >= low) {
            int mid = (low + high) / 2;
            if (key < param[mid]) {
                high = mid - 1;
            } else if (key == param[mid]) {
                return mid;
            } else {
                low = mid + 1;
            }
        }
        return 0;
    }
    //  排序数组  选择排序 冒泡排序    -------快速排序 递归      希尔排序

    //   选择排序
    public static void selectSort(int[] param) {
        for (int i = 0; i < param.length; i++) {
            for (int j = i + 1; j < param.length; j++) {
                if (param[i] > param[j]) {
                    int temp = param[j];
                    param[j] = param[i];
                    param[i] = temp;
                }
            }
        }
        //  java.utils  工具类    ; 专用于排序：  eg:
        Arrays.sort(param);               // 这个是归并排序
        Arrays.parallelSort(param);        //   是一个多线程框架
        Arrays.binarySearch(param, 4);     //  二分查找法;但是必须要经过排序才得行; 然后作用效果就跟自己写的那个差不多了
    }

    //冒泡排序
    public void bubbleSort(int[] a) {
        int temp = 0;
        for (int i = a.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}
